home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 476-500 / disk_500 / wiconify / wiconcalls.lzh / wExample3 / wExample3.c < prev    next >
C/C++ Source or Header  |  1991-04-19  |  8KB  |  318 lines
  1. /*
  2.  *  WEXAMPLE3.C     Example program for wIconify.
  3.  *                  This program uses an icon with an IconPort to check
  4.  *                  when its window is iconified.  Then it closes the
  5.  *                  window and adds an icon to the screen (this saves
  6.  *                  space, since the window is a SMART_REFRESH window).
  7.  *                  When the icon is openned, the window is re-openned.
  8.  */
  9.  
  10. #define INTUITION_PREFERENCES_H             /* don't need 'em */
  11. #include <intuition/intuition.h>
  12.  
  13. #include "wIcon.h"
  14.  
  15. /*
  16.  *  The revision levels needed to the libraries
  17.  */
  18.  
  19. #define INTUITION_REV   0
  20. #define GRAPHICS_REV    0
  21. extern struct IntuitionBase *IntuitionBase;
  22. extern struct GfxBase *GfxBase;
  23.  
  24.  
  25. /*
  26.  *  Return codes for error and OK
  27.  */
  28.  
  29. #define ERROR_EXIT      10
  30. #define OK_EXIT         0
  31.  
  32.  
  33. /*
  34.  *  Some routines we need
  35.  */
  36.  
  37. extern struct Window *OpenWindow();
  38. extern struct Node *GetMsg();
  39. extern struct MsgPort *CreatePort();
  40. extern APTR OpenLibrary();
  41. extern WICONREF *wAddIcon();
  42.  
  43.  
  44. /*
  45.  *  Types of IconMessage to report
  46.  */
  47.  
  48. #define REPORTFLAGS\
  49.   (WI_REPORTICONVERIFY| WI_REPORTOPEN| WI_REPORTCLOSE| WI_REPORTSCREENCLOSE)
  50.  
  51. /*
  52.  *  The definition for our window
  53.  */
  54.  
  55. static struct NewWindow NewWindow =
  56. {
  57.    160,50, 320,100, 0,1, CLOSEWINDOW,
  58.    WINDOWCLOSE| WINDOWDRAG| WINDOWDEPTH| WINDOWSIZING|
  59.      SMART_REFRESH| NOCAREREFRESH,
  60.    NULL, NULL, "wExample3", NULL, NULL, 20,10, -1,-1, WBENCHSCREEN
  61. };
  62. static struct Window *myWindow;
  63. static struct Screen *theScreen;
  64.  
  65.  
  66. /*
  67.  *  This is the icon definition.  It uses the default imagery and flags,
  68.  *  but adds report flags.
  69.  */
  70.  
  71. static WICON myIcon =
  72. {
  73.    "wExample3",         /* No window for this icon, so must provide name */
  74.    NULL,NULL,NULL,      /* Use default Image, Select, and Mask */
  75.    0,0,                 /* Let wIconify place it where it wants */
  76.    0,                   /* No special flags  */
  77.    REPORTFLAGS,         /* The special report flags needed */
  78.    NULL                 /* We'll add the icon port once it is created */
  79. };
  80. static WICONREF *IconRef;
  81.  
  82.  
  83. /*
  84.  *  The Ports and Signals used
  85.  */
  86.  
  87. static struct MsgPort *WindowPort;
  88. static struct MsgPort *IconPort;
  89. static long WindowSignal;
  90. static long IconSignal;
  91.  
  92. /*
  93.  *  DoExit()
  94.  *
  95.  *  Print an error message, if necessary, and then clean up any allocated
  96.  *  memory, close the windows and libraries, etc.  Finally, exit.
  97.  */
  98.  
  99. static void DoExit(s,x1,x2,x3)
  100. char *s, *x1,*x2,*x3;
  101. {
  102.    int status = OK_EXIT;
  103.  
  104.    if (s)
  105.    {
  106.       printf(s,x1,x2,x3);
  107.       printf("\n");
  108.       status = ERROR_EXIT;
  109.    }
  110.    if (IconRef)         wRemoveIcon(IconRef);
  111.    if (myWindow)        CloseWindow(myWindow);
  112.    if (IconPort)        DeletePort(IconPort);
  113.    if (IntuitionBase)   CloseLibrary(IntuitionBase);
  114.    if (GfxBase)         CloseLibrary(GfxBase);
  115.    exit(status);
  116. }
  117.  
  118.  
  119. /*
  120.  *  CheckLibOpen()
  121.  *
  122.  *  Check to see if the specified library can be openned, and exit with
  123.  *  an error if not.
  124.  */
  125.  
  126. static void CheckLibOpen(lib,name,rev)
  127. APTR *lib;
  128. char *name;
  129. int rev;
  130. {
  131.    extern APTR OpenLibrary();
  132.    
  133.    if ((*lib = OpenLibrary(name,(ULONG)rev)) == NULL)
  134.       DoExit("Can't open '%s'",name);
  135. }
  136.  
  137.  
  138. /*
  139.  *  GetPort()
  140.  *
  141.  *  Create the IconPort and attach it to the Icon
  142.  *  Get the signal bit in use by the port
  143.  */
  144.  
  145. static void GetPort()
  146. {
  147.    IconPort = CreatePort(0,0);
  148.    if (IconPort == NULL) DoExit("Can't Create IconPort");
  149.    myIcon.IconPort = IconPort;
  150.    IconSignal = (1 << IconPort->mp_SigBit);
  151. }
  152.  
  153.  
  154. /*
  155.  *  OpenMyWindow()
  156.  *
  157.  *  If an icon is open,
  158.  *    Open the window on the screen where the icon currently exists.
  159.  *  Attempt to open the window (error if unsuccessful).
  160.  *  Add the icon to the window once it's open.
  161.  *  return the window pointer
  162.  */
  163.  
  164. static struct Window *OpenMyWindow()
  165. {
  166.    if (theScreen)
  167.    {
  168.       NewWindow.Screen = theScreen;
  169.       NewWindow.Type = CUSTOMSCREEN;
  170.    }
  171.    myWindow = OpenWindow(&NewWindow);
  172.    if (myWindow == NULL)
  173.    {
  174.       printf("Can't open my window");
  175.    } else {
  176.       wSetIcon(myWindow,&myIcon);
  177.       WindowPort = myWindow->UserPort;
  178.       WindowSignal = (1 << WindowPort->mp_SigBit);
  179.    }
  180.    return(myWindow);
  181. }
  182.  
  183.  
  184. /*
  185.  *  DisplayMessage()
  186.  *
  187.  *  Set the pen color, and write out the message telling the user
  188.  *  what he should do with this window.
  189.  */
  190.  
  191. static void DisplayMessage()
  192. {
  193.    struct RastPort *rp = myWindow->RPort;
  194.  
  195.    SetAPen(rp,3);
  196.    Move(rp,110,43);
  197.    Text(rp,"Iconify Me!",11);
  198.    Move(rp,42,59);
  199.    Text(rp,"(Close me when you're done.)",28);
  200. }
  201.  
  202.  
  203. /*
  204.  *  WaitForAction()
  205.  *
  206.  *  While there is still more to do
  207.  *    Wait for a message to arrive at the window's UserPort
  208.  *    If the window is open
  209.  *      While there are more messages in the port
  210.  *        If the message class is a CLOSEWINDOW message, we're done
  211.  *        Reply to the message
  212.  *    While there are more IconMessages in the port
  213.  *      If the message is ICONVERIFY
  214.  *        Tell wIconify NOT to iconify the window and return the message
  215.  *        Now add the icon to the screen manually
  216.  *        If successful,
  217.  *          if the window is selected, select the new icon
  218.  *          remove the window - it will appear iconify!
  219.  *          clear the window, port and signal variables
  220.  *        Otherwise tell the user we couldn't add the icon
  221.  *      If the message is OPEN
  222.  *        If we have an icon on the screen
  223.  *          Re-open the window and display its message
  224.  *          Get the icon's current data (we are after it's position and flags)
  225.  *          Remove the icon and clear the reference
  226.  *      If the message is CLOSE or SCREENCLOSE
  227.  *        If the icon exists, we're done
  228.  *      Reply to the message
  229.  */
  230.  
  231. static void WaitForAction()
  232. {
  233.    struct IntuiMessage *intuiMessage;
  234.    struct wIconMessage *iconMessage;
  235.    short NotDone = TRUE;
  236.  
  237.    while (NotDone)
  238.    {
  239.       Wait(WindowSignal | IconSignal);
  240.       if (myWindow)
  241.       {
  242.          while (intuiMessage = (struct IntuiMessage *)GetMsg(WindowPort))
  243.          {
  244.             if (intuiMessage->Class == CLOSEWINDOW) NotDone = FALSE;
  245.             ReplyMsg(intuiMessage);
  246.          }
  247.       }
  248.       while (iconMessage = (struct wIconMessage *)GetMsg(IconPort))
  249.       {
  250.          switch(iconMessage->Action)
  251.          {
  252.             case WI_REPORTICONVERIFY:
  253.                iconMessage->Flags &= ~WI_ICONIFYOK;
  254.                ReplyMsg(iconMessage); iconMessage = NULL;
  255.                theScreen = myWindow->WScreen;
  256.                IconRef = wAddIcon(theScreen,&myIcon);
  257.                if (IconRef)
  258.                {
  259.                   if (myWindow->Flags & WINDOWACTIVE)
  260.                      wSelectIcon(IconRef,FALSE);
  261.                   CloseWindow(myWindow); myWindow = NULL;
  262.                   WindowPort = NULL; WindowSignal = 0;
  263.                } else printf(">> Can't Add Icon!");
  264.                break;
  265.  
  266.             case WI_REPORTOPEN:
  267.                if (IconRef)
  268.                {
  269.                   if (OpenMyWindow())
  270.                   {
  271.                      wGetIconData(&myIcon,IconRef);
  272.                      wRemoveIcon(IconRef); IconRef = NULL;
  273.                      DisplayMessage();
  274.                   }
  275.                }
  276.                break;
  277.  
  278.             case WI_REPORTCLOSE:
  279.             case WI_REPORTSCREENCLOSE:
  280.                if (IconRef) NotDone = FALSE;
  281.                break;
  282.          }
  283.          if (iconMessage) ReplyMsg(iconMessage);
  284.       }
  285.    }
  286. }
  287.  
  288.  
  289. /*
  290.  *  main()
  291.  *
  292.  *  If wIconify is running
  293.  *    Open the libraries
  294.  *    Create the IconPort
  295.  *    Open the window and add its icon
  296.  *    Display the message in the window
  297.  *    Wait for something to happen
  298.  *  Otherwise
  299.  *    Print an error message
  300.  *  Clean up and exit
  301.  */
  302.  
  303. void main()
  304. {
  305.    if (wIconifyActive())
  306.    {
  307.       CheckLibOpen(&IntuitionBase,"intuition.library",INTUITION_REV);
  308.       CheckLibOpen(&GfxBase,"graphics.library",GRAPHICS_REV);
  309.       GetPort();
  310.       if (OpenMyWindow())
  311.       {
  312.          DisplayMessage();
  313.          WaitForAction();
  314.       }
  315.    } else printf("wIcoinfy not running or version mismatch\n");
  316.    DoExit(NULL);
  317. }
  318.